duaer-spec 0.1.0 → 0.2.0

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

@@ -5,14 +5,15 @@ alwaysApply: true
 
 # Duaer required (NON-NEGOTIABLE)
 
-See repo `DUADER.md` and `.duaer/memory/constitution.md`.
+Treat agents as digital employees: assign a Brief (Spec) before code; accept
+only via converge. See `DUADER.md` and `.duaer/memory/constitution.md`.
 
 If this rule conflicts with root `AGENTS.md` / `docs/agent/` (worktrees, commits,
 Issue/PR), **AGENTS.md wins**.
 
 ## When Duaer is mandatory
 
-Always write/update a feature spec before coding for:
+Always write/update a feature spec (Brief) before coding for:
 
 - New features / user-visible behavior
 - Architecture or contract changes
@@ -31,3 +32,4 @@ Forbidden: jump from chat to code with no `spec.md` / feature directory under `.
 - 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)

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

@@ -71,10 +71,17 @@ of remaining work as a new, traceable task** at the bottom of `tasks.md` so that
 This is **not** a diff tool and does **not** track changes. It assesses the present state
 of the code relative to the feature's artifacts — no git, no branch comparison, no history.
 
+**Delivery stamp:** Always update `FEATURE_DIR/delivery.json` after assessment (see Step 7).
+That file is what `duaer check --gate` reads for machine-checkable acceptance.
+
 ## Operating Constraints
 
-**APPEND-ONLY, NEVER REWRITE**: The command's **only** write is appending a new
-`## Phase N: Convergence` section to `tasks.md`. It MUST NOT:
+**APPEND-ONLY FOR TASKS, STAMP FOR DELIVERY**: The command's writes are limited to:
+
+1. appending a new `## Phase N: Convergence` section to `tasks.md` when findings exist;
+2. writing / overwriting `FEATURE_DIR/delivery.json` (the machine-readable accept stamp).
+
+It MUST NOT:
 
 - modify `spec.md` or `plan.md` in any way;
 - rewrite, renumber, reorder, or delete any existing task (including tasks from a prior
@@ -83,7 +90,8 @@ of the code relative to the feature's artifacts — no git, no branch comparison
   job of `/duaer-implement`.
 
 When the codebase already satisfies everything, the command MUST leave `tasks.md`
-**byte-for-byte unchanged** (no empty Convergence header) and report a clean result.
+**byte-for-byte unchanged** (no empty Convergence header) and still write
+`delivery.json` with `status: "accepted"`.
 
 **Constitution Authority**: The project constitution (`.duaer/memory/constitution.md`) is
 **non-negotiable**. Code that violates a MUST principle is the highest-severity finding and
@@ -221,20 +229,51 @@ Append to the **end** of `tasks.md`, per the append contract:
    `CRITICAL`.
 4. Never reuse or renumber existing IDs. If a prior Convergence phase exists, add a new,
    separately-numbered one below it — do not touch the old one.
+5. **Write / overwrite** `FEATURE_DIR/delivery.json`:
+
+   ```json
+   {
+     "schemaVersion": 1,
+     "status": "open",
+     "outcome": "tasks_appended",
+     "checkedAt": "<ISO-8601 UTC>",
+     "openTasks": <count of - [ ] in tasks.md after append>,
+     "findings": <number of findings appended>,
+     "source": "duaer-converge"
+   }
+   ```
 
 **If there are no actionable findings** (`converged` outcome):
 
 - Do **not** modify `tasks.md` at all — no empty phase header.
+- **Write / overwrite** `FEATURE_DIR/delivery.json` with:
+
+  ```json
+  {
+    "schemaVersion": 1,
+    "status": "accepted",
+    "outcome": "converged",
+    "checkedAt": "<ISO-8601 UTC>",
+    "openTasks": 0,
+    "findings": 0,
+    "source": "duaer-converge"
+  }
+  ```
+
+  Set `openTasks` to the count of unchecked `- [ ]` lines currently in `tasks.md`
+  (must be `0` for `status: "accepted"`; if any remain, treat as `tasks_appended`
+  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.
 ### 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.
-- On `converged`: recommend proceeding to review / opening a PR. No further implement pass
-  is needed for this feature's specified scope.
+  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.
 
 ### 9. Check for extension hooks
 

package/.duaer/memory/constitution.md

@@ -35,3 +35,8 @@ 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.

package/ADOPT.md

@@ -1,22 +1,21 @@
 # Adopt duaer-spec
 
-Install the **Duaer** methodology and agent-ops contract into another
-repository.
+Onboard a **digital employee** into another repository: install the Duaer
+delivery OS (method) and the agent-ops contract (how they are allowed to work).
 
 ## Recommended: CLI
 
 From the target project (Node 18+):
 
 ```bash
-# GitHub pin
-npx github:fujiezee/duaer-spec@v0.1.0 duaer init --here
-
-# npm (after publish)
 npx duaer-spec init --here
 
-# method only / ops only / other integration branch
-npx github:fujiezee/duaer-spec@v0.1.0 duaer init --here --method
-npx github:fujiezee/duaer-spec@v0.1.0 duaer init --here --ops --branch develop
+# 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
 ```
 
 From a clone of this repo:
@@ -30,9 +29,12 @@ node bin/duaer.mjs check /path/to/project
 
 Then:
 
-1. Edit `.duaer/memory/constitution.md` and `project-context.md` for the product
-2. Confirm `docs/baseline.md` (integration branch)
-3. Use `/duaer-specify` → `/duaer-plan` → `/duaer-tasks` → `/duaer-implement` → `/duaer-converge`
+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`
+
+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.
 
 ## Manual copy (optional)
 
@@ -59,7 +61,7 @@ cp DUADER.md /path/to/project/
 
 ## Precedence
 
-1. `AGENTS.md` / agent-ops — how agents operate  
+1. `AGENTS.md` / agent-ops — how employees operate  
 2. `DUADER.md` / `.duaer/` — what to build  
 3. Product overlays (do not copy `examples/` blindly)
 

package/AGENTS.md

@@ -3,8 +3,10 @@
 Mandatory rules for AI coding agents working in **duaer-spec**, and for any
 repository that adopts this file as its agent-ops contract.
 
-This file is authoritative for *how* agents operate. If Duaer (`.duaer/`,
-`DUADER.md`), `examples/`, or other overlays conflict with this file,
+Treat agents as **digital employees**: this file is the workplace policy for
+*how* they 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**.
 
 See also: [workflow](docs/agent/workflow.md) · [change checklist](docs/agent/change-checklist.md) · [ADOPT](ADOPT.md)

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 0.2.0 — 2026-09-15
+
+### Controllable delivery (machine gate)
+
+- `/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
+
+### E2E
+
+- E2E-003 / E2E-004 / E2E-005 for delivery report and gate
+
+## 0.1.1 — 2026-09-15
+
+### Docs / product identity
+
+- 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)
+
 ## 0.1.0 — 2026-09-15
 
 First public methodology release.

package/DUADER.md

@@ -1,7 +1,10 @@
 # Duaer methodology
 
-**duaer-spec** owns this method. Artifacts live under `.duaer/`; Cursor skills
-are `duaer-*` at `.cursor/skills/`.
+**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.
+
+Artifacts live under `.duaer/`; Cursor skills are `duaer-*` at `.cursor/skills/`.
 
 **Precedence:** root [`AGENTS.md`](AGENTS.md) / [`docs/agent/`](docs/agent/) win
 over anything here for isolation, commits, and Issue/PR gates.
@@ -18,24 +21,25 @@ over anything here for isolation, commits, and Issue/PR gates.
 **Full (recommended):**
 
 1. `/duaer-constitution` — only when principles change
-2. `/duaer-specify` — what / why / acceptance (not stack trivia)
+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` — compare result to spec; append remaining tasks if gaps
+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
 
-**Small feature:** specify → plan → tasks → implement → converge  
+**Small feature:** specify → plan → tasks → implement → converge → `check --gate`  
 
-**Hotfix:** specify (mark hotfix) → tasks → implement → converge  
-Never skip specify or converge.
+**Hotfix:** specify (mark hotfix) → tasks → implement → converge → `check --gate`  
+Never skip specify (assign), converge (accept), or the gate.
 
 ## Install
 
 ```bash
-npx github:fujiezee/duaer-spec duaer init --here
+npx duaer-spec init --here
 ```
 
 Or see [`ADOPT.md`](ADOPT.md). No third-party Spec CLI is required — `duaer`
@@ -45,10 +49,11 @@ installs this repository's method files into the target project.
 
 ```text
 .duaer/specs/<nnn-slug>/
-  spec.md
-  plan.md      # after /duaer-plan
-  tasks.md     # after /duaer-tasks
-  …            # research / contracts as needed
+  spec.md         # Brief
+  plan.md         # after /duaer-plan
+  tasks.md        # after /duaer-tasks
+  delivery.json   # after /duaer-converge (accepted | open)
+  …               # research / contracts as needed
 ```
 
 ## Related

package/README.md

@@ -1,44 +1,70 @@
 # duaer-spec
 
-**Duaer** is a Spec-Driven Development methodology for AI coding agents
-(Cursor first), plus enforceable **agent ops** for isolation, commits, and
-Issue/PR gates.
+**Duaer** is a delivery operating system for AI coding agents treated as
+**digital employees**.
 
-Not a wrapper around another toolkit. The method, directories, skills, and rules
-in this repository **are** duaer-spec.
+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.
 
-## Install into a project
+Cursor is the labor. Duaer is hire → assign → accept.
 
-```bash
-# GitHub (available now)
-npx github:fujiezee/duaer-spec@v0.1.0 duaer init --here
+## Install (onboard the employee)
 
-# npm (after the package is published)
+```bash
 npx duaer-spec init --here
+# or pin: npx github:fujiezee/duaer-spec@v0.2.0 duaer init --here
 ```
 
 ```bash
-# method only / ops only / other integration branch
-npx github:fujiezee/duaer-spec duaer init --here --method
-npx github:fujiezee/duaer-spec duaer init --here --ops --branch develop
+# Lite: method only (personal / small changes)
+npx duaer-spec init --here --method
+
+# Full ops on another integration branch
+npx duaer-spec init --here --ops --branch develop
 ```
 
-Verify: `npx github:fujiezee/duaer-spec duaer check .`  
+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.
+
 ## Two layers
 
 | Layer | Role | Where |
 |---|---|---|
-| **Agent ops** | How agents operate | [`AGENTS.md`](AGENTS.md), [`docs/agent/`](docs/agent/) |
+| **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**.
+When they conflict, **agent ops win** — process beats improvisation.
 
 ## Default loop
 
 ```text
-constitution → specify → plan → tasks → implement → converge
+constitution → specify → plan → tasks → implement → converge → check --gate
 ```
 
 Small change: `specify → plan → tasks → implement → converge`  
@@ -52,14 +78,16 @@ Slash skills: `/duaer-specify`, `/duaer-plan`, `/duaer-tasks`, `/duaer-implement
 ```text
 bin/duaer.mjs             CLI (duaer init | check | version)
 package.json              npm package metadata
-AGENTS.md                 Agent-ops contract
-DUADER.md                 Methodology conventions
-ADOPT.md                  Install guide
+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)
 ```
 

package/bin/duaer.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 /**
- * duaer — CLI for the duaer-spec methodology
+ * duaer — CLI for the duaer-spec delivery OS (digital employees)
  *
  *   duaer init [dir] [--all|--method|--ops] [--force] [--branch <name>]
- *   duaer check [dir]
+ *   duaer check [dir] [--workplace|--delivery|--gate]
  *   duaer version
  *   duaer help
  */
@@ -24,26 +24,35 @@ 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 — Duaer methodology installer (duaer-spec ${PKG.version})
+const USAGE = `duaer — Delivery OS for AI digital employees (duaer-spec ${PKG.version})
+
+Hire agents into a repo, assign Briefs (Specs), accept only when the gate passes.
 
 Usage:
-  duaer init [dir] [options]   Install Duaer into a project
-  duaer check [dir]            Verify install shape
-  duaer version                Print version
-  duaer help                   Show this help
+  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
 
 Init options:
-  --all          Agent ops + method (default)
-  --method       Method only (.duaer, skills, DUADER.md, duaer-spec rule)
-  --ops          Agent ops only (AGENTS.md, docs/agent, ops rules)
+  --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=.
 
+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)
+
 Examples:
-  npx github:fujiezee/duaer-spec duaer init --here
-  node bin/duaer.mjs init ../my-app --all
+  npx duaer-spec init --here
   duaer check .
+  duaer check . --gate
 `
 
 function parseArgs(argv) {
@@ -54,6 +63,9 @@ function parseArgs(argv) {
     mode: 'all',
     force: false,
     branch: 'main',
+    workplace: false,
+    delivery: false,
+    gate: false,
   }
   const rest = args.slice(1)
   for (let i = 0; i < rest.length; i++) {
@@ -63,6 +75,9 @@ function parseArgs(argv) {
     else if (a === '--ops') out.mode = 'ops'
     else if (a === '--force') out.force = true
     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 === '--branch') {
       out.branch = rest[++i]
       if (!out.branch) throw new Error('--branch requires a value')
@@ -86,7 +101,6 @@ function copyPath(from, to, { force }) {
   if (existsSync(to) && !force) {
     const st = statSync(to)
     if (st.isDirectory()) {
-      // merge: copy children carefully
       for (const name of readdirSync(from)) {
         copyPath(join(from, name), join(to, name), { force })
       }
@@ -218,20 +232,101 @@ function cmdInit(opts) {
   }
 
   console.log(`
-Done.
+Hired.
 
-Next:
-  1. Edit .duaer/memory/constitution.md and project-context.md for this product
-  2. Confirm docs/baseline.md (integration branch: ${opts.branch})
-  3. In Cursor, use /duaer-specify → /duaer-plan → /duaer-tasks → /duaer-implement → /duaer-converge
-  4. Agent ops: AGENTS.md wins over DUADER.md when they conflict
+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.
 `)
 }
 
-function cmdCheck(dir) {
-  const target = resolve(dir)
+function countOpenTasks(tasksPath) {
+  if (!existsSync(tasksPath)) return null
+  const text = readFileSync(tasksPath, 'utf8')
+  const open = (text.match(/^\s*-\s*\[\s\]/gm) || []).length
+  const done = (text.match(/^\s*-\s*\[x\]/gim) || []).length
+  return { open, done }
+}
+
+function readDelivery(path) {
+  if (!existsSync(path)) return null
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'))
+  } catch {
+    return { status: 'invalid', error: 'unreadable delivery.json' }
+  }
+}
+
+function listFeatures(target) {
+  const root = join(target, '.duaer', 'specs')
+  if (!existsSync(root)) return []
+  return readdirSync(root)
+    .filter((name) => {
+      try {
+        return statSync(join(root, name)).isDirectory()
+      } catch {
+        return false
+      }
+    })
+    .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
+      }
+
+      return {
+        name,
+        hasSpec,
+        tasks,
+        stamp,
+        verdict,
+        blockers,
+      }
+    })
+}
+
+function checkWorkplace(target) {
   const checks = [
     ['.duaer/memory/constitution.md', 'method'],
     ['DUADER.md', 'method'],
@@ -242,17 +337,95 @@ function cmdCheck(dir) {
     ['docs/agent/workflow.md', 'ops'],
   ]
   let missing = 0
-  console.log(`Checking ${target}\n`)
+  console.log('## Workplace\n')
   for (const [rel, kind] of checks) {
     const ok = existsSync(join(target, rel))
     console.log(`${ok ? 'ok ' : 'MISS'}  [${kind}] ${rel}`)
     if (!ok) missing++
   }
-  if (missing) {
-    console.log(`\n${missing} missing — run: duaer init ${dir} --all`)
-    process.exitCode = 1
+  return missing
+}
+
+function checkDelivery(target, { gate }) {
+  const features = listFeatures(target)
+  console.log('\n## Delivery\n')
+  if (features.length === 0) {
+    console.log('ok   no features under .duaer/specs/ (nothing to accept)')
+    return { blocked: 0, unaccepted: 0, features: 0 }
+  }
+
+  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}`)
+    }
+    if (f.verdict === 'blocked') blocked++
+    if (f.verdict === 'unaccepted') unaccepted++
+  }
+
+  if (gate) {
+    console.log('\nGate mode: every feature must be accepted.')
+  }
+  return { blocked, unaccepted, features: features.length }
+}
+
+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
+
+  console.log(`Checking ${target}${opts.gate ? ' (gate)' : ''}\n`)
+
+  let workplaceMissing = 0
+  if (runWorkplace) {
+    workplaceMissing = checkWorkplace(target)
+  }
+
+  let delivery = { blocked: 0, unaccepted: 0, features: 0 }
+  if (runDelivery) {
+    delivery = checkDelivery(target, { gate: opts.gate })
+  }
+
+  let fail = false
+  if (workplaceMissing) {
+    console.log(`\n${workplaceMissing} workplace file(s) missing — run: duaer init ${opts.dir} --all`)
+    fail = true
+  }
+
+  if (runDelivery) {
+    if (delivery.blocked) {
+      console.log(`\n${delivery.blocked} feature(s) blocked — close open tasks / fix Spec / re-run converge`)
+      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.')
+    } else {
+      console.log('\nDelivery report done.')
+    }
   } else {
-    console.log('\nInstall looks complete.')
+    process.exitCode = 1
   }
 }
 
@@ -272,7 +445,7 @@ function main() {
         cmdInit(opts)
         break
       case 'check':
-        cmdCheck(opts.dir)
+        cmdCheck(opts)
         break
       case 'version':
       case '--version':

package/docs/agent/README.md

@@ -1,7 +1,7 @@
 # Agent workflow (duaer-spec)
 
-Authoritative docs for *how* agents operate. Wins over Duaer and `examples/`
-when they conflict.
+Authoritative docs for *how* digital employees operate (workplace policy).
+Wins over Duaer and `examples/` when they conflict.
 
 | Doc | Description |
 |---|---|

package/docs/agent/change-checklist.md

@@ -94,6 +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).
 - [ ] Branch refreshed against latest `main`.
 - [ ] Merged into local `main` (and/or remote PR/MR when required).
 - [ ] Only this request's logical changes included.
@@ -121,6 +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 |
 | 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

@@ -20,9 +20,16 @@ Status:      planned | automated | manual
 
 ## Catalog
 
+This repository’s own product surface (CLI + docs). Adopters replace or extend
+the table for their app.
+
 | ID | Title | Status |
 |---|---|---|
-| — | *(replace with project scenarios)* | — |
+| 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 |
 
 ## Traceability
 
@@ -30,4 +37,8 @@ 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 |

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duaer-spec",
-  "version": "0.1.0",
-  "description": "Duaer Spec-Driven Development methodology + agent ops for AI coding agents",
+  "version": "0.2.0",
+  "description": "Delivery OS for AI digital employees: Spec briefs, agent ops, check --gate handoffs",
   "type": "module",
   "bin": {
     "duaer": "bin/duaer.mjs",
@@ -36,11 +36,13 @@
   "homepage": "https://github.com/fujiezee/duaer-spec#readme",
   "keywords": [
     "duaer",
+    "digital-employee",
+    "delivery-os",
     "spec-driven",
     "agents",
     "cursor",
     "ai-engineering",
-    "methodology"
+    "controllable-delivery"
   ],
   "license": "MIT",
   "scripts": {